Inter.Net 55-1

home *** CD-ROM | disk | FTP | other *** search

/ Inter.Net 55-1 / Inter.Net 55-1.iso / CBuilder / Setup / BCB / data.z / sysdefs.h < prev next >

Wrap

C/C++ Source or Header | 1998-02-09 | 101.2 KB | 2,950 lines

///////////////////////////////////////////////////////////////////////////// // SYSDEFS.H - Support for properties & vcl intrinsic types // $Revision: 1.28.2.2 $ // Copyright (c) 1997, 1998 Borland International ///////////////////////////////////////////////////////////////////////////// #ifndef SYSDEFS_H #define SYSDEFS_H #pragma comment(lib, "vcle35.lib") #if __BORLANDC__ < 0x500 #error BCW 5.0 or greater required #endif #pragma anon_struct on // support anonymous structs (within unions) #include <windows.h> #if !defined(_BASETYPS_H_) #include <basetyps.h> #endif // Bring in Interface definitions - Supply what may be missing in LEAN_AND_MEAN mode // #if !defined(BEGIN_INTERFACE) // If OBJBASE.H has not been seen yet! #define BEGIN_INTERFACE #endif #if !defined(END_INTERFACE) // If OBJBASE.H has not been seen yet! #define END_INTERFACE #endif #if !defined(WINOLEAPI) // If OBJBASE.H has not been seen yet! #define WINOLEAPI EXTERN_C DECLSPEC_IMPORT HRESULT STDAPICALLTYPE #endif #if !defined(HUGEP) // If OBJBASE.H has not been seen yet! #define HUGEP #endif // The following bring in basic windows types + IUnknown // #include <wtypes.h> #include <unknwn.h> // The following are Automation related structures required by either Variant // or some other VCL Header. We forward ref. the tagStruct and #define the // typedef name to the tagStruct. // interface IDispatch; union tagCY; struct tagSAFEARRAY; struct tagVARIANT; struct tagSTATSTG; #define CURRENCY tagCY #define SAFEARRAY tagSAFEARRAY #define VARIANT tagVARIANT // The following macros must appear before AnsiString and WideString are defined // #define PACKAGE __declspec(package) #define THREAD __declspec(thread) #define PASCALIMPLEMENTATION __declspec(pascalimplementation, package) #define DELPHIRETURN __declspec(delphireturn, package) #define DELPHICLASS __declspec(delphiclass, package) #if !defined(DYNAMIC) #define DYNAMIC __declspec(dynamic) #endif #if !defined(MESSAGE) #define MESSAGE #endif #if !defined(HIDESBASEDYNAMIC) #define HIDESBASEDYNAMIC __declspec(hidesbase, dynamic) #endif #if !defined(HIDESBASE) #define HIDESBASE __declspec(hidesbase) #endif // VCL_IOSTREAM: This macro enables the i/ostream insertion/extraction operators of VCL // classes. The operators are otherwise hidden to cut down on the amount // of lines (i.e. symbols) that must be compiled. (The redefinition of // i/ostream as templates in the Standard Library made these headers // fairly significant). // // If <iostream.h> has already been included, then expose the VCL insertion/extraction operators. // #if defined(__STD_IOSTREAM__) #define VCL_IOSTREAM #elif defined(VCL_IOSTREAM) && !defined(__STD_IOSTREAM__) #include <iostream.h> #endif #if !defined(DSTRING_H) #include <dstring.h> #endif #if !defined(WSTRING_H) #include <wstring.h> #endif //--------------------------------------------------------------------------- // For this header, turn off "function not expanded inline" and // "temp used for param" warnings #pragma option push -w-inl -w-lvc extern "C" __int64 _roundToInt64(long double); #define __safecall __stdcall #define __interface class #define __dispinterface class //forward declarations namespace System { class DELPHIRETURN OleVariant; class DELPHIRETURN Variant; template <class T> class DELPHIRETURN DelphiInterface; class PACKAGE TMetaClass; typedef TMetaClass* TClass; class DELPHIRETURN CurrencyBase { public: __int64 Val; }; class DELPHIRETURN Currency : public CurrencyBase { friend Currency __fastcall operator +(int lhs, const Currency& rhs); friend Currency __fastcall operator -(int lhs, const Currency& rhs); friend Currency __fastcall operator *(int lhs, const Currency& rhs); friend Currency __fastcall operator /(int lhs, const Currency& rhs); friend Currency __fastcall operator +(double lhs, const Currency& rhs); friend Currency __fastcall operator -(double lhs, const Currency& rhs); friend Currency __fastcall operator *(double lhs, const Currency& rhs); friend Currency __fastcall operator /(double lhs, const Currency& rhs); public: __fastcall Currency() {Val = 0;} __fastcall Currency(double val) {Val = _roundToInt64(10000 * val);} __fastcall Currency(int val) {Val = 10000*(__int64)val;} __fastcall Currency(const CurrencyBase& src) {Val = src.Val;} __fastcall Currency(const Currency& src) {Val = src.Val;} __fastcall Currency(const AnsiString& src); Currency& __fastcall operator =(double rhs) { Val = _roundToInt64(10000 * rhs); return *this; } Currency& __fastcall operator =(int rhs) {Val = 10000*(__int64)rhs; return *this;} Currency& __fastcall operator =(const CurrencyBase& rhs) {Val=rhs.Val;return *this;} Currency& __fastcall operator =(const Currency& rhs) {Val = rhs.Val; return *this;} Currency& __fastcall operator +=(const Currency& rhs) {Val += rhs.Val; return *this;} Currency& __fastcall operator -=(const Currency& rhs) {Val -= rhs.Val; return *this;} Currency& __fastcall operator *=(const Currency& rhs) {Val *= rhs.Val; Val /= 10000; return *this;} Currency& __fastcall operator /=(const Currency& rhs) {Val *= 10000; Val /= rhs.Val; return *this;} Currency& __fastcall operator %=(int rhs) {Val %= 10000 * (__int64)rhs; return *this;} Currency& operator ++() {Val += 10000; return *this;} Currency operator ++(int) {Currency tmp(*this); Val += 10000; return tmp;} Currency& operator --() {Val -= 10000; return *this;} Currency operator --(int) {Currency tmp(*this); Val -= 10000; return tmp;} Currency __fastcall operator +(const Currency& rhs) const {Currency tmp(*this); return tmp += rhs;} Currency __fastcall operator -(const Currency& rhs) const {Currency tmp(*this); return tmp -= rhs;} Currency __fastcall operator *(const Currency& rhs) const {Currency tmp(*this); return tmp *= rhs;} Currency __fastcall operator /(const Currency& rhs) const {Currency tmp(*this); return tmp /= rhs;} Currency __fastcall operator +(int rhs) const {Currency tmp(*this); return tmp += Currency(rhs);} Currency __fastcall operator -(int rhs) const {Currency tmp(*this); return tmp -= Currency(rhs);} Currency __fastcall operator *(int rhs) const {Currency tmp(*this); return tmp *= Currency(rhs);} Currency __fastcall operator /(int rhs) const {Currency tmp(*this); return tmp /= Currency(rhs);} Currency __fastcall operator %(int rhs) const {return Currency(static_cast<int>(Val % (10000 * (__int64)rhs))) / 10000;} Currency __fastcall operator +(double rhs) const {Currency tmp(*this); return tmp += Currency(rhs);} Currency __fastcall operator -(double rhs) const {Currency tmp(*this); return tmp -= Currency(rhs);} Currency __fastcall operator *(double rhs) const {Currency tmp(*this); return tmp *= Currency(rhs);} Currency __fastcall operator /(double rhs) const {Currency tmp(*this); return tmp /= Currency(rhs);} Currency __fastcall operator -() const {Currency tmp(*this); tmp.Val = -(tmp.Val); return tmp;} Currency __fastcall operator !() const {Currency tmp(*this); tmp.Val = !(tmp.Val); return tmp;} // comparisons (Currency rhs) bool __fastcall operator ==(const Currency& rhs) const {return Val == rhs.Val;} bool __fastcall operator !=(const Currency& rhs) const {return Val != rhs.Val;} bool __fastcall operator >(const Currency& rhs) const {return Val > rhs.Val;} bool __fastcall operator <(const Currency& rhs) const {return Val < rhs.Val;} bool __fastcall operator >=(const Currency& rhs) const {return Val >= rhs.Val;} bool __fastcall operator <=(const Currency& rhs) const {return Val <= rhs.Val;} // comparisons (int rhs) bool __fastcall operator ==(int rhs) const {return Val == 10000 * (__int64)rhs;} bool __fastcall operator !=(int rhs) const {return Val != 10000 * (__int64)rhs;} bool __fastcall operator >(int rhs) const {return Val > 10000 * (__int64)rhs;} bool __fastcall operator <(int rhs) const {return Val < 10000 * (__int64)rhs;} bool __fastcall operator >=(int rhs) const {return Val >= 10000 * (__int64)rhs;} bool __fastcall operator <=(int rhs) const {return Val <= 10000 * (__int64)rhs;} // comparisons (double rhs) bool __fastcall operator ==(double rhs) const {return Val == _roundToInt64(10000 * (long double)rhs);} bool __fastcall operator !=(double rhs) const {return Val != _roundToInt64(10000 * (long double)rhs);} bool __fastcall operator >(double rhs) const {return Val > _roundToInt64(10000 * (long double)rhs);} bool __fastcall operator <(double rhs) const {return Val < _roundToInt64(10000 * (long double)rhs);} bool __fastcall operator >=(double rhs) const {return Val >= _roundToInt64(10000 * (long double)rhs);} bool __fastcall operator <=(double rhs) const {return Val <= _roundToInt64(10000 * (long double)rhs);} __fastcall operator double() const {return ((double)Val) / 10000;} __fastcall operator int() const {return (int) (Val / 10000);} __fastcall operator AnsiString() const; }; // Currency friends // inline Currency __fastcall operator +(int lhs, const Currency& rhs) {Currency tmp(lhs); return tmp += rhs;} inline Currency __fastcall operator -(int lhs, const Currency& rhs) {Currency tmp(lhs); return tmp -= rhs;} inline Currency __fastcall operator *(int lhs, const Currency& rhs) {Currency tmp(lhs); return tmp *= rhs;} inline Currency __fastcall operator /(int lhs, const Currency& rhs) {Currency tmp(lhs); return tmp /= rhs;} inline Currency __fastcall operator +(double lhs, const Currency& rhs) {Currency tmp(lhs); return tmp += rhs;} inline Currency __fastcall operator -(double lhs, const Currency& rhs) {Currency tmp(lhs); return tmp -= rhs;} inline Currency __fastcall operator *(double lhs, const Currency& rhs) {Currency tmp(lhs); return tmp *= rhs;} inline Currency __fastcall operator /(double lhs, const Currency& rhs) {Currency tmp(lhs); return tmp /= rhs;} // NOTE: Insertion/Extraction operators of VCL classes are only visible // if VCL_IOSTREAM is defined. // #if defined(VCL_IOSTREAM) ostream& operator << (ostream& os, const Currency& arg); istream& operator >> (istream& is, Currency& arg); #endif class DELPHIRETURN TDateTimeBase { public: double Val; }; class DELPHIRETURN TDateTime : public TDateTimeBase { public: // Used by TDateTime(const AnsiString& src) enum TDateTimeFlag {Date, Time, DateTime}; static TDateTime __fastcall CurrentDate(); static TDateTime __fastcall CurrentTime(); static TDateTime __fastcall CurrentDateTime(); static TDateTime __fastcall FileDateToDateTime(int fileDate); __fastcall TDateTime() {Val = 0;} __fastcall TDateTime(const TDateTimeBase& src) {Val = src.Val;} __fastcall TDateTime(const TDateTime& src) {Val = src.Val;} __fastcall TDateTime(const double src) {Val = src;} __fastcall TDateTime(const int src) {Val = src;} __fastcall TDateTime(const AnsiString& src, TDateTimeFlag flag = DateTime); __fastcall TDateTime(unsigned short year, unsigned short month, unsigned short day); __fastcall TDateTime(unsigned short hour, unsigned short min, unsigned short sec, unsigned short msec); TDateTime& __fastcall operator =(const TDateTimeBase& rhs) {Val = rhs.Val;return *this;} TDateTime& __fastcall operator =(const TDateTime& rhs) {Val = rhs.Val; return *this;} TDateTime& __fastcall operator =(const double rhs) {Val = rhs; return *this;} TDateTime& __fastcall operator =(const int rhs) {Val = rhs; return *this;} TDateTime& __fastcall operator +=(const TDateTimeBase& rhs) {Val+=rhs.Val;return *this;} TDateTime& __fastcall operator +=(const TDateTime& rhs) {Val += rhs.Val; return *this;} TDateTime& __fastcall operator +=(const double rhs) {Val += rhs; return *this;} TDateTime& __fastcall operator +=(const int rhs) {Val += rhs; return *this;} TDateTime& __fastcall operator -=(const TDateTimeBase& rhs) {Val-=rhs.Val;return *this;} TDateTime& __fastcall operator -=(const TDateTime& rhs) {Val -= rhs.Val; return *this;} TDateTime& __fastcall operator -=(const double rhs) {Val -= rhs; return *this;} TDateTime& __fastcall operator -=(const int rhs) {Val -= rhs; return *this;} TDateTime& operator ++() {Val++; return *this;} TDateTime operator ++(int) {TDateTime tmp(*this); Val++; return tmp;} TDateTime& operator --() {Val--; return *this;} TDateTime operator --(int) {TDateTime tmp(*this); Val--; return tmp;} TDateTime __fastcall operator +(const TDateTimeBase& rhs) const {return Val+rhs.Val;} TDateTime __fastcall operator +(const TDateTime& rhs) const {return Val+rhs.Val;} TDateTime __fastcall operator +(const double rhs) const {return Val+rhs;} TDateTime __fastcall operator +(const int rhs) const {return Val+rhs;} TDateTime __fastcall operator -(const TDateTimeBase& rhs) const {return Val-rhs.Val;} TDateTime __fastcall operator -(const TDateTime& rhs) const {return Val-rhs.Val;} TDateTime __fastcall operator -(const double rhs) const {return Val-rhs;} TDateTime __fastcall operator -(const int rhs) const {return Val-rhs;} // comparisons bool __fastcall operator ==(const TDateTime& rhs) const {return Val == rhs.Val;} bool __fastcall operator !=(const TDateTime& rhs) const {return Val != rhs.Val;} bool __fastcall operator >(const TDateTime& rhs) const {return Val > rhs.Val;} bool __fastcall operator <(const TDateTime& rhs) const {return Val < rhs.Val;} bool __fastcall operator >=(const TDateTime& rhs) const {return Val >= rhs.Val;} bool __fastcall operator <=(const TDateTime& rhs) const {return Val <= rhs.Val;} __fastcall operator AnsiString() const;//<Date||Time||DateTime>String(smart) AnsiString __fastcall FormatString(const AnsiString& format); AnsiString __fastcall DateString() const; AnsiString __fastcall TimeString() const; AnsiString __fastcall DateTimeString() const; __fastcall operator double() const {return Val;} __fastcall operator int() const {return (int)Val;} int __fastcall DayOfWeek() const; int __fastcall FileDate() const; void __fastcall DecodeDate(unsigned short* year, unsigned short* month, unsigned short* day) const; void __fastcall DecodeTime(unsigned short* hour, unsigned short* min, unsigned short* sec, unsigned short* msec) const; }; // NOTE: Insertion/Extraction operators of VCL classes are only visible // if VCL_IOSTREAM is defined. // #if defined(VCL_IOSTREAM) ostream& operator <<(ostream& os, const TDateTime& arg); istream& operator >>(istream& is, TDateTime& arg); #endif typedef bool Boolean; // typedef int Integer; // -2147483648..2147484647 typedef char Char; // 0..255 typedef wchar_t WideChar; // Unicode character typedef signed char Shortint; // -128..127 typedef short Smallint; // -32768..32767 typedef unsigned char Byte; // 0..255 typedef unsigned short Word; // 0..65535 typedef unsigned long DWord; // 0..4294967295 typedef void* Pointer; // typedef char AnsiChar; // typedef signed long Longint; // -2147483648..2147484647 typedef unsigned int Cardinal; // 0..2147484647 typedef long double Extended; // 10 byte real typedef float Single; // 4 byte real typedef double Double; // 8 byte real typedef char* const Openstring; // D16 string/D32 shortstring formalparm typedef void* file; // typedef void* Text; // typedef Text TextFile; // typedef char* PChar; // typedef char* PAnsiChar; // typedef wchar_t* PWideChar; // typedef unsigned char ByteBool; // typedef unsigned short WordBool; // typedef Cardinal LongBool; // typedef AnsiString String; // typedef SmallStringBase<255> ShortStringBase; // typedef SmallString<255> ShortString; // typedef ShortString* PShortString; // typedef AnsiString* PAnsiString; // typedef PAnsiString PString; // typedef WideString* PWideString; // typedef Extended* PExtended; // typedef Currency* PCurrency; // typedef Variant* PVariant; // typedef __int64 LONG64; // typedef GUID TGUID; // typedef TGUID* PGUID; // typedef HRESULT HResult; // struct PACKAGE TInterfaceEntry { TGUID IID; Pointer VTable; int IOffset; }; typedef TInterfaceEntry *PInterfaceEntry; struct PACKAGE TInterfaceTable { int EntryCount; TInterfaceEntry Entries[]; }; typedef TInterfaceTable *PInterfaceTable; // NOTE: Do not mess with TObject unless you really know what you're doing. // In particular, do not add, remove or change the order of virtual methods. // class DELPHICLASS TObject { public: __fastcall TObject(); /* Body provided by VCL {} */ __fastcall Free(); TClass __fastcall ClassType(); void __fastcall CleanupInstance(); void * __fastcall FieldAddress(const ShortString &Name); /* class method */ static TObject * __fastcall InitInstance(TClass cls, void *instance); /* class method */ static ShortString __fastcall ClassName(TClass cls); /* class method */ static bool __fastcall ClassNameIs(TClass cls, const AnsiString string); /* class method */ static TClass __fastcall ClassParent(TClass cls); /* class method */ static void * __fastcall ClassInfo(TClass cls); /* class method */ static long __fastcall InstanceSize(TClass cls); /* class method */ static bool __fastcall InheritsFrom(TClass cls, TClass aClass); /* class method */ static void * __fastcall MethodAddress(TClass cls, const ShortString &Name); /* class method */ static ShortString __fastcall MethodName(TClass cls, void *Address); bool __fastcall GetInterface(const TGUID &IID, /* out */ void *Obj); /* class method */ static PInterfaceEntry __fastcall GetInterfaceEntry(const TGUID IID); /* class method */ static PInterfaceTable * __fastcall GetInterfaceTable(void); ShortString __fastcall ClassName() { return ClassName(ClassType()); } bool __fastcall ClassNameIs(const AnsiString string) { return ClassNameIs(ClassType(), string); } TClass __fastcall ClassParent() { return ClassParent(ClassType()); } void * __fastcall ClassInfo() { return ClassInfo(ClassType()); } long __fastcall InstanceSize() { return InstanceSize(ClassType()); } bool __fastcall InheritsFrom(TClass aClass) { return InheritsFrom(ClassType(), aClass); } void * __fastcall MethodAddress(const ShortString &Name) { return MethodAddress(ClassType(), Name); } ShortString __fastcall MethodName(void *Address) { return MethodName(ClassType(), Address); } virtual HResult __fastcall SafeCallException(TObject *ExceptObject, void *ExceptAddr); virtual void __fastcall AfterConstruction(); virtual void __fastcall BeforeDestruction(); virtual void __fastcall Dispatch(void *Message); virtual void __fastcall DefaultHandler(void* Message); private: virtual TObject* __fastcall NewInstance(TClass cls); public: virtual void __fastcall FreeInstance(); virtual __fastcall ~TObject(); /* Body provided by VCL {} */ }; class DELPHICLASS TInterfacedObject : TObject { private: void *IUnknown; int FRefCount; protected: virtual HResult __stdcall QueryInterface(const GUID& IID, /* out */ void *Obj); virtual int __stdcall _AddRef(void); virtual int __stdcall _Release(void); public: __property int RefCount = { read=FRefCount }; }; class PACKAGE TMetaClass { public: TObject * __fastcall InitInstance(void *instance) { TObject::InitInstance(this, instance); } ShortString __fastcall ClassName() { return TObject::ClassName(this); } bool __fastcall ClassNameIs(const AnsiString &string) { return TObject::ClassNameIs(this,string); } TClass __fastcall ClassParent() { return TObject::ClassParent(this); } void * __fastcall ClassInfo() { return TObject::ClassInfo(this); } long __fastcall InstanceSize() { return TObject::InstanceSize(this); } bool __fastcall InheritsFrom(TClass aClass) { return TObject::InheritsFrom(this, aClass); } void * __fastcall MethodAddress(const ShortString &Name) { return TObject::MethodAddress(this, Name); } ShortString __fastcall MethodName(void *Address) { return TObject::MethodName(this,Address); } }; #define BEGIN_MESSAGE_MAP virtual void __fastcall Dispatch(void *Message) \ { \ switch (((PMessage)Message)->Msg) \ { #define VCL_MESSAGE_HANDLER(msg,type,meth) \ case msg: \ meth(*((type *)Message)); \ break; // NOTE: ATL defines a MESSAGE_HANDLER macro which conflicts with VCL's macro. The // VCL macro has been renamed to VCL_MESSAGE_HANDLER. If you are not using ATL, // MESSAGE_HANDLER is defined as in previous versions of BCB. // #if !defined(USING_ATL) && !defined(USING_ATLVCL) && !defined(INC_ATL_HEADERS) #define MESSAGE_HANDLER VCL_MESSAGE_HANDLER #endif // ATL_COMPAT #define END_MESSAGE_MAP(base) default: \ base::Dispatch(Message); \ break; \ } \ } // Comp // Range: -263+1 .. 263-1, Significant digits: 19-20, Size: 8 // The Comp (computational) type holds only integral values within -263+1 // to 263-1, which is approximately -9.2 * 1018 to 9.2 * 1018. // struct PACKAGE CompBase { protected: char __data[8]; }; struct PACKAGE Comp : public CompBase { operator =(double d); operator =(Currency d); operator double(); operator Currency(); }; extern PACKAGE double __cdecl CompToDouble(Comp acomp); extern PACKAGE void __cdecl DoubleToComp(double adouble, Comp &result); extern PACKAGE Currency __cdecl CompToCurrency(Comp acomp); extern PACKAGE void __cdecl CurrencyToComp(Currency acurrency, Comp &result); inline Comp::operator = (double d) { DoubleToComp(d, *this); } inline Comp::operator double() { return CompToDouble(*this); } inline Comp::operator = (Currency d) { CurrencyToComp(d, *this); } inline Comp::operator Currency() { return CompToCurrency(*this); } // SetBase<> & Set<> are used to emulate Delphi set types template<class T, unsigned char minEl, unsigned char maxEl> class DELPHIRETURN SetBase { protected: unsigned char Data[((((int)(maxEl/8))-((int)(minEl/8))+1) != 3)? (((int)(maxEl/8))-((int)(minEl/8))+1): 4]; }; template<class T, unsigned char minEl, unsigned char maxEl> class DELPHIRETURN Set : SetBase<T, minEl, maxEl> { // NOTE: Insertion/Extraction operators of VCL classes are only visible // if VCL_IOSTREAM is defined. // #if defined(VCL_IOSTREAM) friend ostream& operator << (ostream& os, const Set& arg) { #pragma option push -w-inl for (int i = minEl; i <= maxEl; i++) if (arg.Contains(static_cast<T>(i))) os << '1'; else os << '0'; return os; #pragma option pop } friend istream& operator >> (istream& is, Set& arg) { #pragma option push -w-inl unsigned char el; for (int i = minEl; i <= maxEl; i++) { is >> el; if (el == '1') arg << static_cast<T>(i); } return is; #pragma option pop } #endif // VCL_IOSTREAM public: __fastcall Set() {memset(Data, 0, sizeof (Data));} __fastcall Set(const Set& src) { #pragma option push -w-inl for (int i = 0; i < sizeof (Data); i++) Data[i] = src.Data[i]; #pragma option pop } Set& __fastcall operator =(const Set& rhs) { #pragma option push -w-inl if (this != &rhs) { for (int i = 0; i < sizeof (Data); i++) Data[i] = rhs.Data[i]; } return *this; #pragma option pop } Set& __fastcall operator +=(const Set& rhs) //Union { #pragma option push -w-inl for (int i = 0; i < sizeof (Data); i++) Data[i] |= rhs.Data[i]; return *this; #pragma option pop } Set& __fastcall operator -=(const Set& rhs) //Difference { #pragma option push -w-inl for (int i = 0; i < sizeof (Data); i++) Data[i] ^= (Data[i] & rhs.Data[i]); return *this; #pragma option pop } Set& __fastcall operator *=(const Set& rhs) //Intersection { #pragma option push -w-inl for (int i = 0; i < sizeof (Data); i++) Data[i] &= rhs.Data[i]; return *this; #pragma option pop } Set __fastcall operator +(const Set& rhs) const //Union { #pragma option push -w-inl Set<T, minEl, maxEl> s; for (int i = 0; i < sizeof (Data); i++) s.Data[i] = Data[i] | rhs.Data[i]; return s; #pragma option pop } Set __fastcall operator -(const Set& rhs) const //Difference { #pragma option push -w-inl Set<T, minEl, maxEl> s; for (int i = 0; i < sizeof (Data); i++) s.Data[i] = Data[i] ^ (Data[i] & rhs.Data[i]); return s; #pragma option pop } Set __fastcall operator *(const Set& rhs) const //Intersection { #pragma option push -w-inl Set<T, minEl, maxEl> s; for (int i = 0; i < sizeof (Data); i++) s.Data[i] = Data[i] & rhs.Data[i]; return s; #pragma option pop } Set& __fastcall operator <<(const T el) //Add element { #pragma warn -ccc #pragma warn -rng if (el >= minEl && el <= maxEl) #pragma warn .ccc #pragma warn .rng Data[(int)(el/8) - (int)(minEl/8)] |= (unsigned char)((unsigned short)1 << (el % 8)); return *this; } Set& __fastcall operator >>(const T el) //Remove element { #pragma warn -ccc #pragma warn -rng if (el >= minEl && el <= maxEl) #pragma warn .ccc #pragma warn .rng Data[(int)(el/8) - (int)(minEl/8)] &= (unsigned char)~((unsigned short)1 << (el % 8)); return *this; } bool __fastcall Contains(const T el) const { #pragma warn -ccc #pragma warn -rng return (el >= minEl && el <= maxEl)? #pragma warn .ccc #pragma warn .rng (Data[(int)(el/8) - (int)(minEl/8)] & (unsigned char)((unsigned short)1 << (el % 8))): false; } Set& __fastcall Clear() { #pragma option push -w-inl for (int i = 0; i < sizeof (Data); i++) Data[i] = 0; return *this; #pragma option pop } bool __fastcall operator ==(const Set& rhs) const { #pragma option push -w-inl for (int i = 0; i < sizeof (Data); i++) if (Data[i] != rhs.Data[i]) // Not so fast, if first or last byte, make sure that // the compare does not include unused bits (mask them) if (i == 0) { if (((0xFF >> (8-(minEl%8))) ^ Data[i]) != ((0xFF >> (8-(minEl%8))) ^ rhs.Data[i])) return false; } else if (sizeof (Data) > 1 && i == sizeof (Data) - 1) { if (((0xFF << (1+(maxEl%8))) ^ Data[i]) != ((0xFF << (1+(maxEl%8))) ^ rhs.Data[i])) return false; } else return false; return true; #pragma option pop } bool __fastcall operator !=(const Set& rhs) const {return !operator==(rhs);} }; class PACKAGE TVarArrayBound { public: Integer ElementCount; Integer LowBound; }; typedef class TVarArray *PVarArray; class PACKAGE TVarArray { public: Word DimCount; Word Flags; Integer ElementSize; Integer LockCount; Pointer Data; TVarArrayBound Bounds[256] /* [0..255] */; }; // Variant Type Descriptors // #define varEmpty (Byte)(0) // VT_EMPTY #define varNull (Byte)(1) // VT_NULL #define varSmallint (Byte)(2) // VT_I2 #define varInteger (Byte)(3) // VT_I3 #define varSingle (Byte)(4) // VT_R4 #define varDouble (Byte)(5) // VT_R8 #define varCurrency (Byte)(6) // VT_CY #define varDate (Byte)(7) // VT_DATE #define varOleStr (Byte)(8) // VT_BSTR #define varDispatch (Byte)(9) // VT_DISPATCH #define varError (Byte)(10) // VT_ERROR #define varBoolean (Byte)(11) // VT_BOOL #define varVariant (Byte)(12) // VT_VARIANT #define varUnknown (Byte)(13) // VT_UNKNOWN #define varByte (Byte)(17) // VT_UI1 #define varString (Word)(256) // ??_?? #define varTypeMask (Word)(4095) // VT_TYPEMASK #define varArray (Word)(8192) // VT_ARRAY #define varByRef (Word)(16384) // VT_BYREF #define varStrArg (Byte)(72) // VT_CLSID #define vtInteger (Byte)(0) #define vtBoolean (Byte)(1) #define vtChar (Byte)(2) #define vtExtended (Byte)(3) #define vtString (Byte)(4) #define vtPointer (Byte)(5) #define vtPChar (Byte)(6) #define vtObject (Byte)(7) #define vtClass (Byte)(8) #define vtWideChar (Byte)(9) #define vtPWideChar (Byte)(10) #define vtAnsiString (Byte)(11) #define vtCurrency (Byte)(12) #define vtVariant (Byte)(13) typedef struct TVarData *PVarData; // TVarData = VARIANT struct PACKAGE TVarData { union { Word VType; // Delphi-compatible - Variant Type member VARTYPE vt; // tagVARIANT compatible member }; Word Reserved1; Word Reserved2; Word Reserved3; union { // Delphi-compatible Variant members Smallint VSmallint; // iVal Integer VInteger; // lVal Single VSingle; // fltVal Double VDouble; // dblVal CurrencyBase VCurrency; // cyVal TDateTimeBase VDate; // date PWideChar VOleStr; // bstrVal IDispatch* VDispatch; // pdispVal HResult VError; // scode WordBool VBoolean; // boolVal IUnknown* VUnknown; // punkVal Byte VByte; // bVal Pointer VString; // ?????? PVarArray VArray; // parray Pointer VPointer; // byref // tagVARIANT compatible members (from OAIDL.H) // Allowing all types marked as [V] (may appear in a VARIANT to be initialized LONG lVal; BYTE bVal; SHORT iVal; FLOAT fltVal; DOUBLE dblVal; VARIANT_BOOL boolVal; SCODE scode; CY cyVal; DATE date; BSTR bstrVal; IUnknown *punkVal; IDispatch *pdispVal; SAFEARRAY *parray; BYTE *pbVal; SHORT *piVal; LONG *plVal; FLOAT *pfltVal; DOUBLE *pdblVal; VARIANT_BOOL *pboolVal; SCODE *pscode; CY *pcyVal; DATE *pdate; BSTR *pbstrVal; IUnknown **ppunkVal; IDispatch **ppdispVal; SAFEARRAY **pparray; VARIANT *pvarVal; PVOID byref; CHAR cVal; USHORT uiVal; ULONG ulVal; INT intVal; UINT uintVal; DECIMAL *pdecVal; CHAR *pcVal; USHORT *puiVal; ULONG *pulVal; INT *pintVal; UINT *puintVal; }; }; class PACKAGE TVarRec; typedef TVarRec* PVarRec; class PACKAGE TVarRec { public: union { Integer VInteger; Boolean VBoolean; Char VChar; PExtended VExtended; PShortString VString; Pointer VPointer; PChar VPChar; TObject* VObject; TClass VClass; WideChar VWideChar; PWideChar VPWideChar; Pointer VAnsiString; PCurrency VCurrency; PVariant VVariant; }; union { Byte VType; long ForceAlignment; #if 0 //! The ForceAlignment should be removed, if alignment set to 4 //! we don't need this #endif }; //---- constructors ---- __fastcall TVarRec(): VType(vtInteger), VInteger(0) {} //default int 0 __fastcall TVarRec(Integer src): VType(vtInteger), VInteger(src) {} __fastcall TVarRec(Boolean src): VType(vtBoolean), VBoolean(src) {} __fastcall TVarRec(char src): VType(vtChar), VChar(src) {} __fastcall TVarRec(const Extended& src): VType(vtExtended), VExtended(const_cast<Extended*>(&src)) {} __fastcall TVarRec(const ShortString& src): VType(vtString), VString(const_cast<PShortString>(&src)) {} __fastcall TVarRec(const Pointer src): VType(vtPointer), VPointer(src) {} __fastcall TVarRec(const PChar src): VType(vtPChar), VPChar(src) {} __fastcall TVarRec(const char* src): VType(vtPChar), VPChar(reinterpret_cast<PChar>(const_cast<char*>(src))) {} __fastcall TVarRec(const TObject& src): VType(vtObject), VObject(const_cast<TObject*>(&src)) {} __fastcall TVarRec(const TClass src): VType(vtClass), VClass(src) {} __fastcall TVarRec(WideChar src): VType(vtWideChar), VWideChar(src) {} __fastcall TVarRec(const PWideChar src): VType(vtPWideChar), VPWideChar(src) {} __fastcall TVarRec(const AnsiString src): VType(vtAnsiString), VAnsiString(src.c_str()) {} __fastcall TVarRec(const Currency& src): VType(vtCurrency), VCurrency(const_cast<PCurrency>(&src)) {} __fastcall TVarRec(const Variant& src): VType(vtVariant), VVariant(const_cast<PVariant>(&src)) {} //---- assignments ---- __fastcall operator =(Integer src) {VType = vtInteger; VInteger = src;} __fastcall operator =(Boolean src) {VType = vtBoolean; VBoolean = src;} __fastcall operator =(char src) {VType = vtChar; VChar = src;} __fastcall operator =(const Extended& src) {VType = vtExtended; VExtended = const_cast<PExtended>(&src);} __fastcall operator =(const ShortString& src) {VType = vtString; VString = const_cast<PShortString>(&src);} __fastcall operator =(const Pointer src) {VType = vtPointer;VPointer = src;} __fastcall operator =(const PChar src) {VType = vtPChar; VPChar = src;} __fastcall operator =(const char* src) {VType = vtPChar; VPChar = reinterpret_cast<PChar>(const_cast<char*>(src));} __fastcall operator =(const TObject& src) {VType = vtObject; VObject = const_cast<TObject*>(&src);} __fastcall operator =(const TClass src) {VType = vtClass; VClass = src;} __fastcall operator =(WideChar src) {VType = vtWideChar; VWideChar = src;} __fastcall operator =(const PWideChar src) {VType = vtPWideChar; VPWideChar = src;} __fastcall operator =(const AnsiString src) {VType = vtAnsiString; VAnsiString = src.c_str();} __fastcall operator =(const Currency& src) {VType = vtCurrency; VCurrency = const_cast<PCurrency>(&src);} __fastcall operator =(const Variant& src) {VType = vtVariant; VVariant = const_cast<PVariant>(&src);} }; template<class T> class OpenArray { public: __fastcall OpenArray(T arg0) { Array = new T[Count = 1]; Array[0] = arg0; } __fastcall OpenArray(T arg0, T arg1) { Array = new T[Count = 2]; Array[0] = arg0; Array[1] = arg1; } __fastcall OpenArray(T arg0, T arg1, T arg2) { Array = new T[Count = 3]; Array[0] = arg0; Array[1] = arg1; Array[2] = arg2; } __fastcall OpenArray(T arg0, T arg1, T arg2, T arg3) { Array = new T[Count = 4]; Array[0] = arg0; Array[1] = arg1; Array[2] = arg2; Array[3] = arg3; } __fastcall OpenArray(T arg0, T arg1, T arg2, T arg3, T arg4) { Array = new T[Count = 5]; Array[0] = arg0; Array[1] = arg1; Array[2] = arg2; Array[3] = arg3; Array[4] = arg4; } __fastcall OpenArray(T arg0, T arg1, T arg2, T arg3, T arg4, T arg5) { Array = new T[Count = 6]; Array[0] = arg0; Array[1] = arg1; Array[2] = arg2; Array[3] = arg3; Array[4] = arg4; Array[5] = arg5; } __fastcall OpenArray(T arg0, T arg1, T arg2, T arg3, T arg4, T arg5, T arg6) { Array = new T[Count = 7]; Array[0] = arg0; Array[1] = arg1; Array[2] = arg2; Array[3] = arg3; Array[4] = arg4; Array[5] = arg5; Array[6] = arg6; } __fastcall OpenArray(T arg0, T arg1, T arg2, T arg3, T arg4, T arg5, T arg6, T arg7) { Array = new T[Count = 8]; Array[0] = arg0; Array[1] = arg1; Array[2] = arg2; Array[3] = arg3; Array[4] = arg4; Array[5] = arg5; Array[6] = arg6; Array[7] = arg7; } __fastcall OpenArray(T arg0, T arg1, T arg2, T arg3, T arg4, T arg5, T arg6, T arg7, T arg8) { Array = new T[Count = 9]; Array[0] = arg0; Array[1] = arg1; Array[2] = arg2; Array[3] = arg3; Array[4] = arg4; Array[5] = arg5; Array[6] = arg6; Array[7] = arg7; Array[8] = arg8; } __fastcall OpenArray(T arg0, T arg1, T arg2, T arg3, T arg4, T arg5, T arg6, T arg7, T arg8, T arg9) { Array = new T[Count = 10]; Array[0] = arg0; Array[1] = arg1; Array[2] = arg2; Array[3] = arg3; Array[4] = arg4; Array[5] = arg5; Array[6] = arg6; Array[7] = arg7; Array[8] = arg8; Array[9] = arg9; } __fastcall OpenArray(T arg0, T arg1, T arg2, T arg3, T arg4, T arg5, T arg6, T arg7, T arg8, T arg9, T arg10) { Array = new T[Count = 11]; Array[0] = arg0; Array[1] = arg1; Array[2] = arg2; Array[3] = arg3; Array[4] = arg4; Array[5] = arg5; Array[6] = arg6; Array[7] = arg7; Array[8] = arg8; Array[9] = arg9; Array[10] = arg10; } __fastcall OpenArray(T arg0, T arg1, T arg2, T arg3, T arg4, T arg5, T arg6, T arg7, T arg8, T arg9, T arg10, T arg11) { Array = new T[Count = 12]; Array[0] = arg0; Array[1] = arg1; Array[2] = arg2; Array[3] = arg3; Array[4] = arg4; Array[5] = arg5; Array[6] = arg6; Array[7] = arg7; Array[8] = arg8; Array[9] = arg9; Array[10] = arg10; Array[11] = arg11; } __fastcall OpenArray(T arg0, T arg1, T arg2, T arg3, T arg4, T arg5, T arg6, T arg7, T arg8, T arg9, T arg10, T arg11, T arg12) { Array = new T[Count = 13]; Array[0] = arg0; Array[1] = arg1; Array[2] = arg2; Array[3] = arg3; Array[4] = arg4; Array[5] = arg5; Array[6] = arg6; Array[7] = arg7; Array[8] = arg8; Array[9] = arg9; Array[10] = arg10; Array[11] = arg11; Array[12] = arg12; } __fastcall OpenArray(T arg0, T arg1, T arg2, T arg3, T arg4, T arg5, T arg6, T arg7, T arg8, T arg9, T arg10, T arg11, T arg12, T arg13) { Array = new T[Count = 14]; Array[0] = arg0; Array[1] = arg1; Array[2] = arg2; Array[3] = arg3; Array[4] = arg4; Array[5] = arg5; Array[6] = arg6; Array[7] = arg7; Array[8] = arg8; Array[9] = arg9; Array[10] = arg10; Array[11] = arg11; Array[12] = arg12; Array[13] = arg13; } __fastcall OpenArray(T arg0, T arg1, T arg2, T arg3, T arg4, T arg5, T arg6, T arg7, T arg8, T arg9, T arg10, T arg11, T arg12, T arg13, T arg14) { Array = new T[Count = 15]; Array[0] = arg0; Array[1] = arg1; Array[2] = arg2; Array[3] = arg3; Array[4] = arg4; Array[5] = arg5; Array[6] = arg6; Array[7] = arg7; Array[8] = arg8; Array[9] = arg9; Array[10] = arg10; Array[11] = arg11; Array[12] = arg12; Array[13] = arg13; Array[14] = arg14; } __fastcall OpenArray(T arg0, T arg1, T arg2, T arg3, T arg4, T arg5, T arg6, T arg7, T arg8, T arg9, T arg10, T arg11, T arg12, T arg13, T arg14, T arg15) { Array = new T[Count = 16]; Array[0] = arg0; Array[1] = arg1; Array[2] = arg2; Array[3] = arg3; Array[4] = arg4; Array[5] = arg5; Array[6] = arg6; Array[7] = arg7; Array[8] = arg8; Array[9] = arg9; Array[10] = arg10; Array[11] = arg11; Array[12] = arg12; Array[13] = arg13; Array[14] = arg14; Array[15] = arg15; } __fastcall OpenArray(T arg0, T arg1, T arg2, T arg3, T arg4, T arg5, T arg6, T arg7, T arg8, T arg9, T arg10, T arg11, T arg12, T arg13, T arg14, T arg15, T arg16) { Array = new T[Count = 17]; Array[0] = arg0; Array[1] = arg1; Array[2] = arg2; Array[3] = arg3; Array[4] = arg4; Array[5] = arg5; Array[6] = arg6; Array[7] = arg7; Array[8] = arg8; Array[9] = arg9; Array[10] = arg10; Array[11] = arg11; Array[12] = arg12; Array[13] = arg13; Array[14] = arg14; Array[15] = arg15; Array[16] = arg16; } __fastcall OpenArray(T arg0, T arg1, T arg2, T arg3, T arg4, T arg5, T arg6, T arg7, T arg8, T arg9, T arg10, T arg11, T arg12, T arg13, T arg14, T arg15, T arg16, T arg17) { Array = new T[Count = 18]; Array[0] = arg0; Array[1] = arg1; Array[2] = arg2; Array[3] = arg3; Array[4] = arg4; Array[5] = arg5; Array[6] = arg6; Array[7] = arg7; Array[8] = arg8; Array[9] = arg9; Array[10] = arg10; Array[11] = arg11; Array[12] = arg12; Array[13] = arg13; Array[14] = arg14; Array[15] = arg15; Array[16] = arg16; Array[17] = arg17; } __fastcall OpenArray(T arg0, T arg1, T arg2, T arg3, T arg4, T arg5, T arg6, T arg7, T arg8, T arg9, T arg10, T arg11, T arg12, T arg13, T arg14, T arg15, T arg16, T arg17, T arg18) { Array = new T[Count = 19]; Array[0] = arg0; Array[1] = arg1; Array[2] = arg2; Array[3] = arg3; Array[4] = arg4; Array[5] = arg5; Array[6] = arg6; Array[7] = arg7; Array[8] = arg8; Array[9] = arg9; Array[10] = arg10; Array[11] = arg11; Array[12] = arg12; Array[13] = arg13; Array[14] = arg14; Array[15] = arg15; Array[16] = arg16; Array[17] = arg17; Array[18] = arg18; } __fastcall OpenArray(const OpenArray& src) { Array = new T[Count = src.Count]; for (int i = 0; i < Count; i++) Array[i] = src.Array[i]; } __fastcall ~OpenArray() {delete [] Array;} OpenArray& __fastcall operator =(const OpenArray& rhs); __fastcall operator T*() {return Array;} int __fastcall GetHigh() {return Count - 1;} private: T* Array; long Count; }; template<class T> OpenArray& __fastcall OpenArray<T>::operator =(const OpenArray& rhs) { if (this != &rhs) { Array = new T[Count = rhs.Count]; for (int i = 0; i < Count; i++) Array[i] = rhs.Array[i]; } return *this; } // Used with OPENARRAY macro (immediately following this template declaration) template<class T> class OpenArrayCount { public: __fastcall OpenArrayCount(T arg0): Count(1) {} __fastcall OpenArrayCount(T arg0,T arg1): Count(2) {} __fastcall OpenArrayCount(T arg0,T arg1,T arg2): Count(3) {} __fastcall OpenArrayCount(T arg0,T arg1,T arg2,T arg3): Count(4) {} __fastcall OpenArrayCount(T arg0,T arg1,T arg2,T arg3,T arg4): Count(5) {} __fastcall OpenArrayCount(T arg0,T arg1,T arg2,T arg3,T arg4, T arg5) : Count(6) {} __fastcall OpenArrayCount(T arg0, T arg1, T arg2, T arg3, T arg4, T arg5, T arg6): Count(7) {} __fastcall OpenArrayCount(T arg0, T arg1, T arg2, T arg3, T arg4, T arg5, T arg6, T arg7): Count(8) {} __fastcall OpenArrayCount(T arg0, T arg1, T arg2, T arg3, T arg4, T arg5, T arg6, T arg7, T arg8): Count(9) {} __fastcall OpenArrayCount(T arg0, T arg1, T arg2, T arg3, T arg4, T arg5, T arg6, T arg7, T arg8, T arg9): Count(10) {} __fastcall OpenArrayCount(T arg0, T arg1, T arg2, T arg3, T arg4, T arg5, T arg6, T arg7, T arg8, T arg9, T arg10): Count(11) {} __fastcall OpenArrayCount(T arg0, T arg1, T arg2, T arg3, T arg4, T arg5, T arg6, T arg7, T arg8, T arg9, T arg10, T arg11): Count(12) {} __fastcall OpenArrayCount(T arg0, T arg1, T arg2, T arg3, T arg4, T arg5, T arg6, T arg7, T arg8, T arg9, T arg10, T arg11, T arg12): Count(13) {} __fastcall OpenArrayCount(T arg0, T arg1, T arg2, T arg3, T arg4, T arg5, T arg6, T arg7, T arg8, T arg9, T arg10, T arg11, T arg12, T arg13) : Count(14) {} __fastcall OpenArrayCount(T arg0, T arg1, T arg2, T arg3, T arg4, T arg5, T arg6, T arg7, T arg8, T arg9, T arg10, T arg11, T arg12, T arg13, T arg14): Count(15) {} __fastcall OpenArrayCount(T arg0, T arg1, T arg2, T arg3, T arg4, T arg5, T arg6, T arg7, T arg8, T arg9, T arg10, T arg11, T arg12, T arg13, T arg14, T arg15): Count(16) {} __fastcall OpenArrayCount(T arg0, T arg1, T arg2, T arg3, T arg4, T arg5, T arg6, T arg7, T arg8, T arg9, T arg10, T arg11, T arg12, T arg13, T arg14, T arg15, T arg16): Count(17) {} __fastcall OpenArrayCount(T arg0, T arg1, T arg2, T arg3, T arg4, T arg5, T arg6, T arg7, T arg8, T arg9, T arg10, T arg11, T arg12, T arg13, T arg14, T arg15, T arg16, T arg17): Count(18) {} __fastcall OpenArrayCount(T arg0, T arg1, T arg2, T arg3, T arg4, T arg5, T arg6, T arg7, T arg8, T arg9, T arg10, T arg11, T arg12, T arg13, T arg14, T arg15, T arg16, T arg17, T arg18): Count(19) {} int __fastcall GetHigh() {return Count - 1;} private: long Count; }; // OPENARRAY: construct an OpenArray<type> on the fly #define OPENARRAY(type, values) \ OpenArray<type>values, OpenArrayCount<type>values.GetHigh() // ARRAYOFCONST: construct an OpenArray<TVarRec> on the fly #define ARRAYOFCONST(values) \ OpenArray<TVarRec>values, OpenArrayCount<TVarRec>values.GetHigh() #define ARRAYSIZE(a) (sizeof(a)/sizeof(a[0])) // EXISTINGARRAY: pass an existing array where an open array is expected #define EXISTINGARRAY(a) (a), ((sizeof(a)/sizeof(a[0]))-1) // SLICE: pass part of an existing array where an open array is expected #define SLICE(a, n) (a), (n - 1) // Encapsulates error code to be stored in Variant // class VariantError { public: VariantError(SCODE err = DISP_E_PARAMNOTFOUND) : m_scode(err) {} operator SCODE () const { return m_scode; } VariantError& operator = (SCODE err) { m_scode = err; return *this; } protected: SCODE m_scode; }; class PACKAGE AutoCmd; class DELPHIRETURN Variant: public TVarData { friend class PACKAGE AutoCmd; // NOTE: Insertion/Extraction operators of VCL classes are only visible // if VCL_IOSTREAM is defined. // #if defined(VCL_IOSTREAM) friend ostream& operator << (ostream& os, const Variant& arg); #endif public: static Variant __fastcall CreateObject(const String& ProgID); static Variant __fastcall GetActiveObject(const String& ProgID); // Default Ctr __fastcall Variant(); // Copy Ctr __fastcall Variant(const Variant& src); // Ctr - From basic C++ types __fastcall Variant(const bool src); __fastcall Variant(const char src); __fastcall Variant(const signed char src); __fastcall Variant(const unsigned char src); __fastcall Variant(const short src); __fastcall Variant(const unsigned short src); __fastcall Variant(const int src); __fastcall Variant(const unsigned int src); __fastcall Variant(const long src); __fastcall Variant(const unsigned long src); __fastcall Variant(const float src); __fastcall Variant(const double src); __fastcall Variant(const long double src); // Ctr - From OLE structures __fastcall Variant(const CURRENCY& src); __fastcall Variant(SAFEARRAY& src); __fastcall Variant(SAFEARRAY* src); __fastcall Variant(const VARIANT& src); __fastcall Variant(VARIANT* src); // Ctr - From utility classes __fastcall Variant(const AnsiString& src); __fastcall Variant(const Currency& src); __fastcall Variant(const TDateTime& src); __fastcall Variant(const VariantError& src); __fastcall Variant(const WideString& src); // Asciiz pointer __fastcall Variant(const char* src); // Treated as pointer Asciiz string // Ctr - OLE ptrs __fastcall Variant(wchar_t* src); // BSTR support __fastcall Variant(IUnknown* src); __fastcall Variant(IDispatch* src); // Ref-counted Dispatch interface object __fastcall Variant(const System::DelphiInterface<IDispatch>& src); //By ref constructors __fastcall Variant(signed char* src); __fastcall Variant(unsigned char* src); __fastcall Variant(short* src); __fastcall Variant(unsigned short* src); __fastcall Variant(int* src); __fastcall Variant(unsigned int* src); __fastcall Variant(long* src); __fastcall Variant(unsigned long* src); __fastcall Variant(float* src); __fastcall Variant(double* src); __fastcall Variant(CURRENCY* src); __fastcall Variant(SAFEARRAY** src); __fastcall Variant(wchar_t** src); // VT_BSTR|VT_BYREF // Ref Vcl classes __fastcall Variant(Currency* src); __fastcall Variant(TDateTime* src); // Constructor for array of variants of type varType __fastcall Variant(const int* bounds, const int boundsSize, Word varType); // Constructor for one dimensional array of type Variant __fastcall Variant(const Variant* values, const int valuesSize); __fastcall ~Variant(); // Assignments Variant& __fastcall operator =(const Variant& rhs); Variant& __fastcall operator =(const bool src); Variant& __fastcall operator =(const char src); Variant& __fastcall operator =(const signed char src); Variant& __fastcall operator =(const unsigned char src); Variant& __fastcall operator =(const short src); Variant& __fastcall operator =(const unsigned short src); Variant& __fastcall operator =(const int src); Variant& __fastcall operator =(const unsigned int src); Variant& __fastcall operator =(const long src); Variant& __fastcall operator =(const unsigned long src); Variant& __fastcall operator =(const float src); Variant& __fastcall operator =(const double src); Variant& __fastcall operator =(const CURRENCY& src); Variant& __fastcall operator =(SAFEARRAY* src); Variant& __fastcall operator =(SAFEARRAY& src); Variant& __fastcall operator =(VARIANT& rhs); Variant& __fastcall operator =(VARIANT* rhs); Variant& __fastcall operator =(const AnsiString& src); Variant& __fastcall operator =(const Currency& src); Variant& __fastcall operator =(const TDateTime& src); Variant& __fastcall operator =(const VariantError& src); Variant& __fastcall operator =(const WideString& src); Variant& __fastcall operator =(const System::DelphiInterface<IDispatch>& src); Variant& __fastcall operator =(wchar_t* src); // BSTR support Variant& __fastcall operator =(IUnknown* src); Variant& __fastcall operator =(IDispatch* src); // By ref Assignment Variant& __fastcall operator =(const char* src); // Treated as pointer Asciiz string Variant& __fastcall operator =(signed char* src); Variant& __fastcall operator =(unsigned char* src); Variant& __fastcall operator =(short* src); Variant& __fastcall operator =(unsigned short* src); Variant& __fastcall operator =(int* src); Variant& __fastcall operator =(unsigned int* src); Variant& __fastcall operator =(long* src); Variant& __fastcall operator =(unsigned long* src); Variant& __fastcall operator =(float* src); Variant& __fastcall operator =(double* src); Variant& __fastcall operator =(CURRENCY* src); Variant& __fastcall operator =(SAFEARRAY** src); Variant& __fastcall operator =(wchar_t** src); // VT_BSTR|VT_BYREF Variant& __fastcall operator =(IUnknown** src); Variant& __fastcall operator =(IDispatch** src); Variant& __fastcall operator =(Currency* src); Variant& __fastcall operator =(TDateTime* src); // Exotic operators Variant& __fastcall operator +=(const Variant& rhs); Variant& __fastcall operator -=(const Variant& rhs); Variant& __fastcall operator *=(const Variant& rhs); Variant& __fastcall operator /=(const Variant& rhs); Variant& __fastcall operator %=(const Variant& rhs); Variant& __fastcall operator &=(const Variant& rhs); Variant& __fastcall operator |=(const Variant& rhs); Variant& __fastcall operator ^=(const Variant& rhs); Variant& __fastcall operator <<=(const Variant& rhs); Variant& __fastcall operator >>=(const Variant& rhs); // comparisons (Variant on right) bool __fastcall operator ==(const Variant& rhs) const; bool __fastcall operator !=(const Variant& rhs) const; bool __fastcall operator < (const Variant& rhs) const; bool __fastcall operator > (const Variant& rhs) const; bool __fastcall operator <=(const Variant& rhs) const; bool __fastcall operator >=(const Variant& rhs) const; // comparisons (int on right) bool __fastcall operator ==(int rhs) const {return operator ==(Variant(rhs));} bool __fastcall operator !=(int rhs) const {return operator !=(Variant(rhs));} bool __fastcall operator < (int rhs) const {return operator < (Variant(rhs));} bool __fastcall operator > (int rhs) const {return operator > (Variant(rhs));} bool __fastcall operator <=(int rhs) const {return operator <=(Variant(rhs));} bool __fastcall operator >=(int rhs) const {return operator >=(Variant(rhs));} // comparisons (string on right) bool __fastcall operator ==(const AnsiString& rhs) const { return AnsiString(*this) == rhs;} // comparisons (double on right) bool __fastcall operator ==(double rhs) const {return operator ==(Variant(rhs));} bool __fastcall operator !=(double rhs) const {return operator !=(Variant(rhs));} bool __fastcall operator < (double rhs) const {return operator <(Variant(rhs));} bool __fastcall operator > (double rhs) const {return operator >(Variant(rhs));} bool __fastcall operator <=(double rhs) const {return operator <=(Variant(rhs));} bool __fastcall operator >=(double rhs) const {return operator >=(Variant(rhs));} // binary operators (Variant on right) Variant __fastcall operator +(const Variant& rhs) const; Variant __fastcall operator -(const Variant& rhs) const; Variant __fastcall operator *(const Variant& rhs) const; Variant __fastcall operator /(const Variant& rhs) const; Variant __fastcall operator %(const Variant& rhs) const; Variant __fastcall operator &(const Variant& rhs) const; Variant __fastcall operator |(const Variant& rhs) const; Variant __fastcall operator ^(const Variant& rhs) const; Variant __fastcall operator <<(const Variant& rhs) const; Variant __fastcall operator >>(const Variant& rhs) const; // binary operators (AnsiString on right) Variant __fastcall operator -(const AnsiString& rhs) const {return operator -(Variant(rhs));} Variant __fastcall operator *(const AnsiString& rhs) const {return operator *(Variant(rhs));} Variant __fastcall operator /(const AnsiString& rhs) const {return operator /(Variant(rhs));} Variant __fastcall operator %(const AnsiString& rhs) const {return operator %(Variant(rhs));} Variant __fastcall operator &(const AnsiString& rhs) const {return operator &(Variant(rhs));} Variant __fastcall operator |(const AnsiString& rhs) const {return operator |(Variant(rhs));} Variant __fastcall operator ^(const AnsiString& rhs) const {return operator ^(Variant(rhs));} Variant __fastcall operator <<(const AnsiString& rhs) const {return operator <<(Variant(rhs));} Variant __fastcall operator >>(const AnsiString& rhs) const {return operator >>(Variant(rhs));} // binary operators (int on right) Variant __fastcall operator +(int rhs) const {return operator +(Variant(rhs));} Variant __fastcall operator -(int rhs) const {return operator -(Variant(rhs));} Variant __fastcall operator *(int rhs) const {return operator *(Variant(rhs));} Variant __fastcall operator /(int rhs) const {return operator /(Variant(rhs));} Variant __fastcall operator %(int rhs) const {return operator %(Variant(rhs));} Variant __fastcall operator &(int rhs) const {return operator &(Variant(rhs));} Variant __fastcall operator |(int rhs) const {return operator |(Variant(rhs));} Variant __fastcall operator ^(int rhs) const {return operator ^(Variant(rhs));} Variant __fastcall operator <<(int rhs) const {return operator <<(Variant(rhs));} Variant __fastcall operator >>(int rhs) const {return operator >>(Variant(rhs));} // binary operators (double on right) Variant __fastcall operator +(double rhs) const {return operator +(Variant(rhs));} Variant __fastcall operator -(double rhs) const {return operator -(Variant(rhs));} Variant __fastcall operator *(double rhs) const {return operator *(Variant(rhs));} Variant __fastcall operator /(double rhs) const {return operator /(Variant(rhs));} Variant __fastcall operator %(double rhs) const {return operator %(Variant(rhs));} Variant __fastcall operator &(double rhs) const {return operator &(Variant(rhs));} Variant __fastcall operator |(double rhs) const {return operator |(Variant(rhs));} Variant __fastcall operator ^(double rhs) const {return operator ^(Variant(rhs));} Variant __fastcall operator <<(double rhs) const {return operator <<(Variant(rhs));} Variant __fastcall operator >>(double rhs) const {return operator >>(Variant(rhs));} // unary operators Variant __fastcall operator -() const; Variant __fastcall operator !() const; // Conversion operators __fastcall operator bool() const; __fastcall operator char() const; __fastcall operator signed char() const; __fastcall operator unsigned char() const; __fastcall operator short() const; __fastcall operator unsigned short() const; __fastcall operator int() const; __fastcall operator unsigned int() const; __fastcall operator long() const; __fastcall operator unsigned long() const; __fastcall operator float() const; __fastcall operator double() const; __fastcall operator AnsiString() const; __fastcall operator Currency() const; __fastcall operator TDateTime() const; __fastcall operator WideString() const; __fastcall operator CURRENCY() const; __fastcall operator VARIANT(); __fastcall operator wchar_t*() const; __fastcall operator IDispatch*(); __fastcall operator IUnknown*(); // by ref conversion operators /*__fastcall operator char*();*/ // Dangerous - easily used as string instead of VT_I1|VT_BYREF __fastcall operator signed char*(); __fastcall operator unsigned char*(); __fastcall operator short*(); __fastcall operator unsigned short*(); __fastcall operator int*(); __fastcall operator unsigned int*(); __fastcall operator long*(); __fastcall operator unsigned long*(); __fastcall operator float*(); __fastcall operator double*(); /*__fastcall operator CURRENCY*() const;*/ /*__fastcall operator SAFEARRAY**() const;*/ __fastcall operator VARIANT*(); __fastcall operator Currency*(); __fastcall operator TDateTime*(); __fastcall operator wchar_t**(); // HRESULT methods // void __fastcall SetError(const HResult err); HResult __fastcall GetError() const; // Manipulate/Set vt_xxx Type // void __fastcall Clear(); Variant& __fastcall ChangeType(int VarType); Variant __fastcall AsType(int VarType) const; // Query vt_xxx Type // int __fastcall Type() const; bool __fastcall IsNull() const; bool __fastcall IsEmpty() const; // Get Base Variant (when vt==VT_VARIANT) // Variant* __fastcall GetBaseVariant(); // Array support // bool __fastcall IsArray() const; Variant __fastcall GetElement(const int i1) const; Variant __fastcall GetElement(const int i1, const int i2) const; Variant __fastcall GetElement(const int i1, const int i2, const int i3) const; Variant __fastcall GetElement(const int i1, const int i2, const int i3, const int i4) const; Variant __fastcall GetElement(const int i1, const int i2, const int i3, const int i4, const int i5) const; void __fastcall PutElement(const Variant& data, const int i1); void __fastcall PutElement(const Variant& data, const int i1, const int i2); void __fastcall PutElement(const Variant& data, const int i1, const int i2,const int i3); void __fastcall PutElement(const Variant& data, const int i1, const int i2,const int i3, const int i4); void __fastcall PutElement(const Variant& data, const int i1, const int i2,const int i3, const int i4, const int i5); int __fastcall ArrayDimCount() const; int __fastcall ArrayLowBound(const int dim = 1) const; int __fastcall ArrayHighBound(const int dim = 1) const; void __fastcall ArrayRedim(int highBound); Pointer __fastcall ArrayLock(); void __fastcall ArrayUnlock(); // Automation Goodies // Variant __fastcall Exec(AutoCmd& cmd, Integer lcid = LOCALE_SYSTEM_DEFAULT) const; // Alternate Syntax for Automation // (Doesn't support Named Parameters) // void OleProcedure(const String& name, Variant& v0 = Empty(), Variant& v1 = Empty(),Variant& v2 = Empty(),Variant& v3 = Empty(), Variant& v4 = Empty(),Variant& v5 = Empty(),Variant& v6 = Empty(), Variant& v7 = Empty(),Variant& v8 = Empty(),Variant& v9 = Empty()) const; Variant OleFunction(const String& name, Variant& v0 = Empty(), Variant& v1 = Empty(),Variant& v2 = Empty(),Variant& v3 = Empty(), Variant& v4 = Empty(),Variant& v5 = Empty(),Variant& v6 = Empty(), Variant& v7 = Empty(),Variant& v8 = Empty(),Variant& v9 = Empty()) const; Variant OlePropertyGet(const String& name, Variant& v0 = Empty(), Variant& v1 = Empty(),Variant& v2 = Empty(),Variant& v3 = Empty(), Variant& v4 = Empty(),Variant& v5 = Empty(),Variant& v6 = Empty(), Variant& v7 = Empty(),Variant& v8 = Empty(),Variant& v9 = Empty()) const; void OlePropertySet(const String& name, Variant& v0 = Empty(), Variant& v1 = Empty(),Variant& v2 = Empty(),Variant& v3 = Empty(), Variant& v4 = Empty(),Variant& v5 = Empty(),Variant& v6 = Empty(), Variant& v7 = Empty(),Variant& v8 = Empty(),Variant& v9 = Empty()) const; // End of Alternate Syntax for Automation // Ref. to Variant which can be used for non-specified optional parameters or 'Empty' parameters static Variant& NoParam(); static Variant& Empty(); private: // AutoCmd::GetParm & GetNamedParm uses operator [] (AutoCmd is a friend) // operator[] can only be used for arrays of type Variant Variant& __fastcall operator [](const int idx); }; // Sanity check //#if sizeof(Variant) != sizeof(VARIANT) //#pragma message("sizeof(Variant) != sizeof(VARIANT)") //#endif class DELPHIRETURN OleVariant: protected Variant { public: __fastcall OleVariant() : Variant() {} __fastcall OleVariant(const OleVariant& src): Variant(src) {} __fastcall OleVariant(const Variant& src) : Variant(src) { // Switch to BSTR if we're an AnsiString Variant // if (Type() == varString) ChangeType(varOleStr); } //By value constructors __fastcall OleVariant(const short src) : Variant(src) {} __fastcall OleVariant(const int src) : Variant(src) {} __fastcall OleVariant(const float src) : Variant(src) {} __fastcall OleVariant(const double src) : Variant(src) {} __fastcall OleVariant(const Currency src) : Variant(src) {} __fastcall OleVariant(const TDateTime src) : Variant(src) {} __fastcall OleVariant(const WideString& src): Variant(src) {} __fastcall OleVariant(const bool src) : Variant(src) {} __fastcall OleVariant(const Byte src) : Variant(src) {} __fastcall OleVariant(wchar_t* const src) : Variant(src) {} __fastcall OleVariant(IDispatch* const src) : Variant(src) {} __fastcall OleVariant(IUnknown* const src) : Variant(src) {} __fastcall OleVariant(VARIANT* src) : Variant(src) {} //By ref constructors __fastcall OleVariant(short* src) : Variant(src) {} __fastcall OleVariant(int* src) : Variant(src) {} __fastcall OleVariant(float* src) : Variant(src) {} __fastcall OleVariant(double* src) : Variant(src) {} __fastcall OleVariant(Currency* src) : Variant(src) {} __fastcall OleVariant(TDateTime* src) : Variant(src) {} __fastcall OleVariant(WordBool* src) : Variant(src) {} __fastcall OleVariant(Byte* src) : Variant(src) {} __fastcall OleVariant(wchar_t** src) : Variant(src) {} // constructor for array of variants of type varType __fastcall OleVariant(const int* bounds, const int boundsSize, Word varType) : Variant(bounds, boundsSize, varType) {} // constructor for one dimensional array of type OleVariant __fastcall OleVariant(const OleVariant* values, const int valuesSize) : Variant(values, valuesSize) {} __fastcall ~OleVariant() {} // Assignment operators // OleVariant& __fastcall operator =(const OleVariant& rhs) { PVariant(this)->operator=(rhs); return *this; } OleVariant& __fastcall operator =(const Variant& rhs) { PVariant(this)->operator=(rhs); // Switch to BSTR if we're an AnsiString Variant // if (Type() == varString) ChangeType(varOleStr); return *this; } OleVariant& __fastcall operator =(VARIANT& rhs) { PVariant(this)->operator=(rhs); return *this; } public: TVarData::VType; TVarData::Reserved1; TVarData::Reserved2; TVarData::Reserved3; TVarData::VSmallint; TVarData::VInteger; TVarData::VSingle; TVarData::VDouble; TVarData::VCurrency; TVarData::VDate; TVarData::VOleStr; TVarData::VDispatch; TVarData::VError; TVarData::VBoolean; TVarData::VUnknown; TVarData::VByte; /* //!BB Hide this - OleVariant cannot hold ansi string TVarData::VString; */ TVarData::VArray; TVarData::VPointer; Variant::operator += ; Variant::operator -= ; Variant::operator *= ; Variant::operator /= ; Variant::operator %= ; Variant::operator &= ; Variant::operator |= ; Variant::operator ^= ; Variant::operator <<=; Variant::operator >>=; // comparisons (Variant on right) Variant::operator == ; Variant::operator != ; Variant::operator < ; Variant::operator > ; Variant::operator <= ; Variant::operator >= ; // unary operators Variant::operator -; Variant::operator !; // conversion operators Variant::operator short; Variant::operator int; Variant::operator float; Variant::operator double; Variant::operator Currency; Variant::operator TDateTime; Variant::operator bool; Variant::operator WideString; Variant::operator unsigned short; Variant::operator IDispatch*; Variant::operator IUnknown*; Variant::operator VARIANT; // by ref conversion operators Variant::operator short*; Variant::operator int*; Variant::operator float*; Variant::operator double*; Variant::operator Currency*; Variant::operator TDateTime*; Variant::operator unsigned short*; Variant::operator Byte*; Variant::operator wchar_t**; // HRESULT methods Variant::SetError; Variant::GetError; Variant::Clear; Variant::ChangeType; Variant::AsType; Variant::Type; Variant::IsNull; Variant::IsEmpty; // variant array stuff Variant::IsArray; Variant::GetElement; Variant::PutElement; Variant::ArrayDimCount; Variant::ArrayLowBound; Variant::ArrayHighBound; Variant::ArrayRedim; Variant::ArrayLock; Variant::ArrayUnlock; // Automation Goodies Variant::Exec; // Alternate Syntax for Automation Variant::OleProcedure; Variant::OleFunction; Variant::OlePropertyGet; Variant::OlePropertySet; private: // binary operators (AnsiString on right) OleVariant __fastcall operator * (const AnsiString& rhs) const; OleVariant __fastcall operator / (const AnsiString& rhs) const; OleVariant __fastcall operator % (const AnsiString& rhs) const; OleVariant __fastcall operator & (const AnsiString& rhs) const; OleVariant __fastcall operator | (const AnsiString& rhs) const; OleVariant __fastcall operator ^ (const AnsiString& rhs) const; OleVariant __fastcall operator <<(const AnsiString& rhs) const; OleVariant __fastcall operator >>(const AnsiString& rhs) const; }; // Variant global scope comparisons (int on left) inline bool __fastcall operator ==(int lhs, const Variant& rhs) {return Variant(lhs).operator ==(rhs);} inline bool __fastcall operator !=(int lhs, const Variant& rhs) {return Variant(lhs).operator !=(rhs);} inline bool __fastcall operator < (int lhs, const Variant& rhs) {return Variant(lhs).operator < (rhs);} inline bool __fastcall operator > (int lhs, const Variant& rhs) {return Variant(lhs).operator > (rhs);} inline bool __fastcall operator <=(int lhs, const Variant& rhs) {return Variant(lhs).operator <=(rhs);} inline bool __fastcall operator >=(int lhs, const Variant& rhs) {return Variant(lhs).operator >=(rhs);} // Variant global scope comparisons (double on left) inline bool __fastcall operator ==(double lhs, const Variant& rhs) {return Variant(lhs).operator ==(rhs);} inline bool __fastcall operator !=(double lhs, const Variant& rhs) {return Variant(lhs).operator !=(rhs);} inline bool __fastcall operator < (double lhs, const Variant& rhs) {return Variant(lhs).operator < (rhs);} inline bool __fastcall operator > (double lhs, const Variant& rhs) {return Variant(lhs).operator > (rhs);} inline bool __fastcall operator <=(double lhs, const Variant& rhs) {return Variant(lhs).operator <=(rhs);} inline bool __fastcall operator >=(double lhs, const Variant& rhs) {return Variant(lhs).operator >=(rhs);} // Variant binary global scope operators (AnsiString on left) inline Variant __fastcall operator - (const AnsiString& lhs, const Variant& rhs) {return Variant(lhs).operator -(rhs);} inline Variant __fastcall operator * (const AnsiString& lhs, const Variant& rhs) {return Variant(lhs).operator *(rhs);} inline Variant __fastcall operator / (const AnsiString& lhs, const Variant& rhs) {return Variant(lhs).operator /(rhs);} inline Variant __fastcall operator % (const AnsiString& lhs, const Variant& rhs) {return Variant(lhs).operator %(rhs);} inline Variant __fastcall operator & (const AnsiString& lhs, const Variant& rhs) {return Variant(lhs).operator &(rhs);} inline Variant __fastcall operator | (const AnsiString& lhs, const Variant& rhs) {return Variant(lhs).operator |(rhs);} inline Variant __fastcall operator ^ (const AnsiString& lhs, const Variant& rhs) {return Variant(lhs).operator ^(rhs);} inline Variant __fastcall operator <<(const AnsiString& lhs, const Variant& rhs) {return Variant(lhs).operator <<(rhs);} inline Variant __fastcall operator >>(const AnsiString& lhs, const Variant& rhs) {return Variant(lhs).operator >>(rhs);} // Variant binary global scope operators (int on left) inline Variant __fastcall operator +(int lhs, const Variant& rhs) {return Variant(lhs).operator +(rhs);} inline Variant __fastcall operator -(int lhs, const Variant& rhs) {return Variant(lhs).operator -(rhs);} inline Variant __fastcall operator *(int lhs, const Variant& rhs) {return Variant(lhs).operator *(rhs);} inline Variant __fastcall operator /(int lhs, const Variant& rhs) {return Variant(lhs).operator /(rhs);} inline Variant __fastcall operator %(int lhs, const Variant& rhs) {return Variant(lhs).operator %(rhs);} inline Variant __fastcall operator &(int lhs, const Variant& rhs) {return Variant(lhs).operator &(rhs);} inline Variant __fastcall operator |(int lhs, const Variant& rhs) {return Variant(lhs).operator |(rhs);} inline Variant __fastcall operator ^(int lhs, const Variant& rhs) {return Variant(lhs).operator ^(rhs);} inline Variant __fastcall operator <<(int lhs, const Variant& rhs) {return Variant(lhs).operator <<(rhs);} inline Variant __fastcall operator >>(int lhs, const Variant& rhs) {return Variant(lhs).operator >>(rhs);} // Variant binary global scope operators (double on left) inline Variant __fastcall operator +(double lhs, const Variant& rhs) {return Variant(lhs).operator +(rhs);} inline Variant __fastcall operator -(double lhs, const Variant& rhs) {return Variant(lhs).operator -(rhs);} inline Variant __fastcall operator *(double lhs, const Variant& rhs) {return Variant(lhs).operator *(rhs);} inline Variant __fastcall operator /(double lhs, const Variant& rhs) {return Variant(lhs).operator /(rhs);} inline Variant __fastcall operator %(double lhs, const Variant& rhs) {return Variant(lhs).operator %(rhs);} inline Variant __fastcall operator &(double lhs, const Variant& rhs) {return Variant(lhs).operator &(rhs);} inline Variant __fastcall operator |(double lhs, const Variant& rhs) {return Variant(lhs).operator |(rhs);} inline Variant __fastcall operator ^(double lhs, const Variant& rhs) {return Variant(lhs).operator ^(rhs);} inline Variant __fastcall operator <<(double lhs, const Variant& rhs) {return Variant(lhs).operator <<(rhs);} inline Variant __fastcall operator >>(double lhs, const Variant& rhs) {return Variant(lhs).operator >>(rhs);} // NOTE: Defined in Delphi - Keep in sync. // #define MaxDispArgs (Byte)(32) class PACKAGE NamedParm; class PACKAGE AutoCmd { public: AutoCmd(const String& name); AutoCmd(const AutoCmd& src); ~AutoCmd(); // Set(update) name of command virtual AutoCmd& SetName(const String& name); // Named arg virtual AutoCmd& operator <<(const NamedParm& np); // By value args virtual AutoCmd& operator <<(const Variant& arg); virtual AutoCmd& operator <<(const short arg); virtual AutoCmd& operator <<(const int arg); virtual AutoCmd& operator <<(const float arg); virtual AutoCmd& operator <<(const double arg); virtual AutoCmd& operator <<(const Currency arg); virtual AutoCmd& operator <<(const TDateTime arg); virtual AutoCmd& operator <<(const bool arg); virtual AutoCmd& operator <<(const WordBool arg); virtual AutoCmd& operator <<(const Byte arg); virtual AutoCmd& operator <<(const AnsiString& arg); virtual AutoCmd& operator <<(const char* arg) // treat as asciiz pointer {return operator <<(AnsiString(arg));} #if 0 //!JK not allowed virtual AutoCmd& operator <<(wchar_t* const arg); #endif virtual AutoCmd& operator <<(IDispatch* const arg); virtual AutoCmd& operator <<(IUnknown* const arg); //By ref args virtual AutoCmd& operator <<(Variant* arg); virtual AutoCmd& operator <<(short* arg); virtual AutoCmd& operator <<(int* arg); virtual AutoCmd& operator <<(float* arg); virtual AutoCmd& operator <<(double* arg); virtual AutoCmd& operator <<(Currency* arg); virtual AutoCmd& operator <<(TDateTime* arg); virtual AutoCmd& operator <<(WordBool* arg); virtual AutoCmd& operator <<(Byte* arg); #if 0 //!JK not allowed virtual AutoCmd& operator <<(wchar_t** arg); #endif virtual AutoCmd& operator <<(AnsiString* arg); virtual AutoCmd& Clear(); // ClearName() + ClearArgs() virtual AutoCmd& ClearName(); // SetName("") virtual AutoCmd& ClearArgs(); // Clear Parms and NamedParms virtual Byte GetCallType() const = 0; virtual bool RequestResult() const = 0; virtual int GetArgType(const Byte idx) const; virtual int GetNamedArgType(const Byte idx) const; virtual String GetName() const { return Name;} virtual Byte GetArgCount() const; virtual Byte GetNamedArgCount() const; virtual Variant& GetParm(const Byte idx); virtual Variant& GetNamedParm(const Byte idx); virtual String GetNamedParmName(const Byte idx) const; virtual String GetStringArg(const Byte idx) {return StringArgs[idx];} virtual String* GetStringPtr(const Byte idx) {return StringPtrs[idx];} virtual String GetNamedStringArg(const Byte idx) {return NamedStringArgs[idx];} virtual String* GetNamedStringPtr(const Byte idx) {return NamedStringPtrs[idx];} protected: void AddElement(); String Name; // name of command Variant Parms; // positional arguments Variant ParmTypes; // types of positional arguments Variant NamedParms; // named arguments Variant NamedParmTypes; // types of named arguments Variant NamedParmNames; // names of named arguments AnsiString StringArgs[MaxDispArgs]; // AnsiString* StringPtrs[MaxDispArgs]; // AnsiString NamedStringArgs[MaxDispArgs]; // AnsiString* NamedStringPtrs[MaxDispArgs]; // }; class PACKAGE NamedParm { public: //By value ctors NamedParm(const String& name, const Variant& arg): Name(name), Type(varVariant), Parm(arg) {} NamedParm(const String& name, const short arg): Name(name), Type(varSmallint), Parm(arg) {} NamedParm(const String& name, const int arg): Name(name), Type(varInteger), Parm(arg) {} NamedParm(const String& name, const float arg): Name(name), Type(varSingle), Parm(arg) {} NamedParm(const String& name, const double arg): Name(name), Type(varDouble), Parm(arg) {} NamedParm(const String& name, const Currency arg): Name(name), Type(varCurrency), Parm(arg) {} NamedParm(const String& name, const TDateTime arg): Name(name), Type(varDate), Parm(arg) {} NamedParm(const String& name, const bool arg): Name(name), Type(varBoolean), Parm(arg) {} NamedParm(const String& name, const WordBool arg): Name(name), Type(varBoolean), Parm(arg) {} NamedParm(const String& name, const Byte arg): Name(name), Type(varByte), Parm(arg) {} NamedParm(const String& name, const AnsiString& arg): Name(name), Type(varString), StringParm(arg) {} NamedParm(const String& name, const char* arg): // treat as asciiz pointer Name(name), Type(varString), StringParm(arg) {} #if 0 //!JK not allowed NamedParm(const String& name, wchar_t* const arg): //!JK not allowed Name(name), Type(varOleStr), Parm(arg) {} #endif NamedParm(const String& name, IDispatch* const arg): Name(name), Type(varDispatch), Parm(arg) {} NamedParm(const String& name, IUnknown* const arg): Name(name), Type(varUnknown), Parm(arg) {} //By ref ctors NamedParm(const String& name, Variant* arg); NamedParm(const String& name, short* arg): Name(name), Type(varSmallint | varByRef), Parm(arg) {} NamedParm(const String& name, int* arg): Name(name), Type(varInteger | varByRef), Parm(arg) {} NamedParm(const String& name, float* arg): Name(name), Type(varSingle | varByRef), Parm(arg) {} NamedParm(const String& name, double* arg): Name(name), Type(varDouble | varByRef), Parm(arg) {} NamedParm(const String& name, Currency* arg): Name(name), Type(varCurrency | varByRef), Parm(arg) {} NamedParm(const String& name, TDateTime* arg): Name(name), Type(varDate | varByRef), Parm(arg) {} NamedParm(const String& name, WordBool* arg): Name(name), Type(varBoolean | varByRef), Parm(arg) {} NamedParm(const String& name, Byte* arg): Name(name), Type(varByte | varByRef), Parm(arg) {} #if 0 //!JK not allowed NamedParm(const String& name, wchar_t** arg): //!JK not allowed Name(name), Type(varOleStr | varByRef), Parm(arg) {} #endif NamedParm(const String& name, String* arg): Name(name), Type(varString | varByRef), StringPtr(arg) {} virtual Variant GetParm() const { return Parm;} virtual AnsiString GetStringParm() const { return StringParm;} virtual AnsiString* GetStringPtr() const { return StringPtr;} virtual int GetType() const { return Type;} virtual String GetParmName() const { return Name;} protected: void AddElement(); String Name; Variant Parm; AnsiString StringParm; AnsiString* StringPtr; int Type; }; class PACKAGE Procedure : public AutoCmd { public: Procedure(const String& name): AutoCmd(name) {} Procedure(const AutoCmd& src): AutoCmd(src) {dynamic_cast<const Procedure*>(&src);} virtual Byte GetCallType() const; virtual bool RequestResult() const { return false;} }; class PACKAGE Function : public AutoCmd { public: Function(const String& name): AutoCmd(name) {} Function(const AutoCmd& src): AutoCmd(src) {dynamic_cast<const Function*>(&src);} virtual Byte GetCallType() const; virtual bool RequestResult() const { return true;} }; class PACKAGE PropertySet : public AutoCmd { public: PropertySet(const String& name): AutoCmd(name) {} PropertySet(const AutoCmd& src): AutoCmd(src) {dynamic_cast<const PropertySet*>(&src);} virtual Byte GetCallType() const; virtual bool RequestResult() const { return false;} }; class PACKAGE PropertyGet : public AutoCmd { public: PropertyGet(const String& name): AutoCmd(name) {} PropertyGet(const AutoCmd& src): AutoCmd(src) {dynamic_cast<const PropertyGet*>(&src);} virtual Byte GetCallType() const; virtual bool RequestResult() const { return true;} }; typedef class TMemoryManager *PMemoryManager; class PACKAGE TMemoryManager { public: Pointer __fastcall (*GetMem)(Integer Size); Integer __fastcall (*FreeMem)(Pointer P); Pointer __fastcall (*ReallocMem)(Pointer P, Integer Size); } ; class PACKAGE THeapStatus { public: Cardinal TotalAddrSpace; Cardinal TotalUncommitted; Cardinal TotalCommitted; Cardinal TotalAllocated; Cardinal TotalFree; Cardinal FreeSmall; Cardinal FreeBig; Cardinal Unused; Cardinal Overhead; Cardinal HeapErrorCode; } ; typedef Integer __fastcall (*TThreadFunc)(Pointer Parameter); #ifdef BCBVER1 #define USEDATAMODULE(FileName, DataModuleName) \ class DELPHICLASS T##DataModuleName; \ extern T##DataModuleName *DataModuleName; #else #define USEDATAMODULE(FileName, DataModuleName) \ class DELPHICLASS T##DataModuleName; \ extern PACKAGE T##DataModuleName *DataModuleName; #endif #ifdef BCBVER1 #define USEDATAMODULENS(FileName, UnitName, DataModuleName) \ namespace UnitName { \ class DELPHICLASS T##DataModuleName; \ extern T##DataModuleName *DataModuleName; \ }; \ using namespace UnitName #else #define USEDATAMODULENS(FileName, UnitName, DataModuleName) \ namespace UnitName { \ class DELPHICLASS T##DataModuleName; \ extern PACKAGE T##DataModuleName *DataModuleName; \ }; \ using namespace UnitName #endif #ifdef BCBVER1 #define USEFORM(FileName, FormName) \ class DELPHICLASS T##FormName; \ extern T##FormName *FormName; #else #define USEFORM(FileName, FormName) \ class DELPHICLASS T##FormName; \ extern PACKAGE T##FormName *FormName; #endif #ifdef BCBVER1 #define USEFORMNS(FileName, UnitName, FormName) \ namespace UnitName { \ class DELPHICLASS T##FormName; \ extern T##FormName *FormName; \ }; \ using namespace UnitName #else #define USEFORMNS(FileName, UnitName, FormName) \ namespace UnitName { \ class DELPHICLASS T##FormName; \ extern PACKAGE T##FormName *FormName; \ }; \ using namespace UnitName #endif #define USEUNIT(ModName) \ extern PACKAGE DummyThatIsNeverReferenced #define USEOBJ(FileName) \ extern PACKAGE DummyThatIsNeverReferenced #define USERC(FileName) \ extern PACKAGE DummyThatIsNeverReferenced #define USEASM(FileName) \ extern PACKAGE DummyThatIsNeverReferenced #define USEDEF(FileName) \ extern PACKAGE DummyThatIsNeverReferenced #define USERES(FileName) \ extern PACKAGE DummyThatIsNeverReferenced #define USETLB(FileName) \ extern PACKAGE DummyThatIsNeverReferenced #define USELIB(FileName) \ extern PACKAGE DummyThatIsNeverReferenced #define USEFILE(FileName) \ extern PACKAGE DummyThatIsNeverReferenced #define USEPACKAGE(FileName) \ extern PACKAGE DummyThatIsNeverReferenced struct PACKAGE ResourceString { HINSTANCE *hinstance; unsigned long id; // resource string id }; extern PACKAGE AnsiString __fastcall LoadResourceString(ResourceString const * const rsrc); typedef void (*TModuleUnloadProc)(HINSTANCE hinstance); typedef bool (*TEnumModuleFunc)(HINSTANCE hinstance, void *data); struct PACKAGE TModuleUnloadRec { TModuleUnloadRec *next; TModuleUnloadProc *proc; }; typedef TModuleUnloadRec *PModuleUnloadRec; struct PACKAGE TLibModule { TLibModule *next; long instance; long resinstance; long reserved; }; typedef TLibModule *PLibModule; struct PACKAGE TResStringRec { long module; long ident; }; typedef TResStringRec *PResStringRec; extern PACKAGE void __fastcall VarClear(Variant& v); /* variant.cpp */ extern PACKAGE void __fastcall VarCast(Variant &dest, const Variant& source, int type); /* variant.cpp */ extern PACKAGE void __fastcall VarArrayRedim(Variant& a, int high); /* variant.cpp */ /* DelphInterface This template class is to be used for allowing Delphi-owned interfaces to be returned from Pascal function to C++ functions. Since Delphi automatically provides reference counting for these references (removing a huge burden from the programmer), the class implemented strives to maintain this features for the C++ programmer. The following invariants must hold: sizeof(DelphiInterface<T>) == 4 template DelphiInterface<T> must be marked DELPHIRETURN BCC32 for BCB 3.0 or later must be used to compile this template reference counting must be provided by the ctor, copy ctor, operator= and dtor. the template type T must be derived from a class which has an AddRef and Release. The following general rules apply: - the T* and T** operators do not perform reference counting; it is the responsibility of the programmer to ensure that refernce handling is correctly performed when these two conversion operators are used. - taking the address of the interface stored in a DelphiInterface<T> does NOT: - release the previous interface - increment the reference count of the current interface - it is the responsibility of the programmer to ensure that reference counting is handled properly when the T** operator is used. - if no interface is stored in a DelphiInterface<T>, the T* operator will return 0. */ template <class T> class DELPHIRETURN DelphiInterface { private: T *intf; public: __fastcall DelphiInterface<T>() : intf(0) {} __fastcall DelphiInterface<T>(const DelphiInterface<T> &rhs) { if (rhs.intf != 0) rhs.intf->AddRef(); intf = rhs.intf; } __fastcall DelphiInterface<T>(T* rhs) { if (rhs != 0) rhs->AddRef(); intf = rhs; } __fastcall ~DelphiInterface<T>() { if (intf != 0) intf->Release(); intf = 0; } __fastcall DelphiInterface<T>& operator =(DelphiInterface<T> &rhs) { if (rhs.intf != 0) rhs.intf->AddRef(); if (intf != 0) intf->Release(); intf = rhs.intf; return *this; } __fastcall DelphiInterface<T>& operator =(T *rhs) { if (rhs != 0) rhs->AddRef(); if (intf != 0) intf->Release(); intf = rhs; return *this; } T* __fastcall operator->() const { return intf; } bool operator ! () const { return (intf == 0); }; __fastcall operator T*() const { return intf; } T& __fastcall operator *() { return *intf; } void Release() { if (intf) intf->Release(); intf = 0; } T** __fastcall operator &() { return &intf; } }; extern PACKAGE void __fastcall CheckSafecallResult(HRESULT hr); } // namespace System using namespace System; // Type definition of interfaces wrapped by a smart object // #if !defined(DECLARE_DINTERFACE_TYPE) #define DECLARE_DINTERFACE_TYPE(iface) \ interface iface; \ typedef System::DelphiInterface< iface > _di_ ## iface; #endif // DECLARE_DINTERFACE_TYPE DECLARE_DINTERFACE_TYPE(IUnknown) DECLARE_DINTERFACE_TYPE(IDispatch) DECLARE_DINTERFACE_TYPE(IAdviseSink) DECLARE_DINTERFACE_TYPE(IDataObject) DECLARE_DINTERFACE_TYPE(IEnumOLEVERB) DECLARE_DINTERFACE_TYPE(IEnumSTATDATA) DECLARE_DINTERFACE_TYPE(ILockBytes) DECLARE_DINTERFACE_TYPE(IMalloc) DECLARE_DINTERFACE_TYPE(IMoniker) DECLARE_DINTERFACE_TYPE(IOleAdviseHolder) DECLARE_DINTERFACE_TYPE(IOleClientSite) DECLARE_DINTERFACE_TYPE(IOleContainer) DECLARE_DINTERFACE_TYPE(IOleInPlaceActiveObject) DECLARE_DINTERFACE_TYPE(IOleInPlaceFrame) DECLARE_DINTERFACE_TYPE(IOleInPlaceObject) DECLARE_DINTERFACE_TYPE(IOleInPlaceSite) DECLARE_DINTERFACE_TYPE(IOleInPlaceUIWindow) DECLARE_DINTERFACE_TYPE(IOleObject) DECLARE_DINTERFACE_TYPE(IStorage) DECLARE_DINTERFACE_TYPE(IStream) DECLARE_DINTERFACE_TYPE(ITypeInfo) DECLARE_DINTERFACE_TYPE(ITypeLib) DECLARE_DINTERFACE_TYPE(IConnectionPointContainer) DECLARE_DINTERFACE_TYPE(IConnectionPoint) DECLARE_DINTERFACE_TYPE(IEnumConnectionPoints) DECLARE_DINTERFACE_TYPE(ISimpleFrameSite) DECLARE_DINTERFACE_TYPE(IPropertyBag) DECLARE_DINTERFACE_TYPE(IEnumConnections) DECLARE_DINTERFACE_TYPE(IOleControl) DECLARE_DINTERFACE_TYPE(IOleControlSite) DECLARE_DINTERFACE_TYPE(IPerPropertyBrowsing) DECLARE_DINTERFACE_TYPE(IFontDisp) DECLARE_DINTERFACE_TYPE(IPersistStreamInit) DECLARE_DINTERFACE_TYPE(IPicture) DECLARE_DINTERFACE_TYPE(IPictureDisp) DECLARE_DINTERFACE_TYPE(IPropertyPageSite) DECLARE_DINTERFACE_TYPE(IOleClientSite) DECLARE_DINTERFACE_TYPE(IErrorLog) DECLARE_DINTERFACE_TYPE(IEnumOLEVERB) DECLARE_DINTERFACE_TYPE(IOleDocumentView) DECLARE_DINTERFACE_TYPE(IOleAdviseHolder) DECLARE_DINTERFACE_TYPE(IOleContainer) DECLARE_DINTERFACE_TYPE(IOleInPlaceActiveObject) DECLARE_DINTERFACE_TYPE(IOleInPlaceObject) DECLARE_DINTERFACE_TYPE(IOleInPlaceUIWindow) DECLARE_DINTERFACE_TYPE(IOleInPlaceFrame) DECLARE_DINTERFACE_TYPE(IOleObject) DECLARE_DINTERFACE_TYPE(IOleInPlaceSite) namespace Typinfo { struct TTypeInfo; typedef TTypeInfo *PTypeInfo; } namespace Controls { typedef System::TDateTime TDate; typedef System::TDateTime TTime; } // Define VCL_IOSTREAM operators // #if defined(VCL_IOSTREAM) namespace System { inline void read_to_delim(istream& strm, char delim, AnsiString& str) { char ch; int nchars = 0; char array[4096]; int capacity = sizeof array; while ( 1 ) { // Read as many characters as we can, up to the delimiter: strm.get( array+nchars, capacity-nchars+1, delim ); // This is the new string length: nchars += strlen( array+nchars ); // What stopped us? An EOF? if ( !strm.good() ) break; // EOF encountered (or worse!) // Nope. Was it the delimiter? strm.get(ch); if (ch==delim) break; // Yup. We're done. Don't put it back on the stream. else strm.putback(ch); // Nope, Put it back and keep going. } str = array; } inline istream& operator >> (istream& is, AnsiString& arg) { read_to_delim(is, 0, arg); return is; } inline ostream& operator << (ostream& os, const AnsiString& arg) { return os << arg.c_str(); } template <unsigned char sz> inline ostream& operator << (ostream& os, const SmallString<sz>& arg) { os << AnsiString(arg).c_str(); return os; } template <unsigned char sz> inline istream& operator >> (istream& is, SmallString<sz>& arg) { AnsiString s; is >> s; arg = s; return is; } // Currency IOStream operators // inline ostream& operator << (ostream& os, const Currency& arg) { os << AnsiString(arg); return os; } inline istream& operator >> (istream& is, Currency& arg) { AnsiString s; is >> s; arg = s; return is; } // TDateTime IOStream operators // inline ostream& operator << (ostream& os, const TDateTime& arg) { os << AnsiString(arg); return os; } inline istream& operator >> (istream& is, TDateTime& arg) { AnsiString s; is >> s; arg = s; return is; } // Variant IOStream operators // inline ostream& operator <<(ostream& os, const Variant& arg) { switch (arg.VType) { case varEmpty: os << "varEmpty"; break; case varNull: os << "varNull"; break; case varSmallint: os << "varSmallint: " << arg.VSmallint; break; case varInteger: os << "varInteger: " << arg.VInteger; break; case varSingle: os << "varSingle: " << arg.VSingle; break; case varDouble: os << "varDouble: " << arg.VDouble; break; case varCurrency: os << "varCurrency: " << arg.VCurrency; break; case varDate: os << "varDate: " << arg.VDate; break; case varOleStr: os << "varOleStr: " << AnsiString(arg.VOleStr); break; case varDispatch: os << "varDispatch: " << static_cast<void*>(arg.VDispatch); break; case varError: os << "varError: " << arg.VError; break; case varBoolean: os << "varBoolean: " << arg.operator bool(); break; case varUnknown: os << "varUnknown: " << static_cast<void*>(arg.VUnknown); break; case varByte: os << "varByte: " << arg.VByte; break; case varString: os << "varString: " << arg.operator AnsiString(); break; case varArray: os << "varArray: " << static_cast<void*>(arg.VArray); break; case varSmallint | varByRef: os << "varSmallint | varByRef: " << arg.VPointer; break; case varInteger | varByRef: os << "varInteger | varByRef: " << arg.VPointer; break; case varSingle | varByRef: os << "varSingle | varByRef: " << arg.VPointer; break; case varDouble | varByRef: os << "varDouble | varByRef: " << arg.VPointer; break; case varCurrency | varByRef: os << "varCurrency | varByRef: " << arg.VPointer; break; case varDate | varByRef: os << "varDate | varByRef: " << arg.VPointer; break; case varOleStr | varByRef: os << "varOleStr | varByRef: " << arg.VPointer; break; case varDispatch | varByRef: os << "varDispatch | varByRef: " << arg.VPointer; break; case varError | varByRef: os << "varError | varByRef: " << arg.VPointer; break; case varBoolean | varByRef: os << "varBoolean | varByRef: " << arg.VPointer; break; case varUnknown | varByRef: os << "varUnknown | varByRef: " << arg.VPointer; break; case varByte | varByRef: os << "varByte | varByRef: " << arg.VPointer; break; case varString | varByRef: os << "varString | varByRef: " << arg.VPointer; break; case varArray | varByRef: os << "varArray | varByRef: " << arg.VPointer; break; } return os; } } // namespace System #endif // VCL_IOSTREAM #if !defined(__typeinfo) #define __typeinfo(type) (PTypeInfo)TObject::ClassInfo(__classid(type)) #endif #pragma option pop // Undo the MACROs which mapped the Automation related types to their tagStruct. // #if defined(CURRENCY) #undef CURRENCY #endif #if defined(SAFEARRAY) #undef SAFEARRAY #endif #if defined(VARIANT) #undef VARIANT #endif #endif // SYSDEFS_H